home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / perl / 5.10.0 / CORE / pp.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-06-26  |  17.7 KB  |  510 lines
  1. /*    pp.h
  2.  *
  3.  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
  4.  *    2001, 2002, 2003, 2004, 2005, 2006, 2007, by Larry Wall and others
  5.  *
  6.  *    You may distribute under the terms of either the GNU General Public
  7.  *    License or the Artistic License, as specified in the README file.
  8.  *
  9.  */
  10.  
  11. #define PP(s) OP * Perl_##s(pTHX)
  12.  
  13. /*
  14. =head1 Stack Manipulation Macros
  15.  
  16. =for apidoc AmU||SP
  17. Stack pointer.  This is usually handled by C<xsubpp>.  See C<dSP> and
  18. C<SPAGAIN>.
  19.  
  20. =for apidoc AmU||MARK
  21. Stack marker variable for the XSUB.  See C<dMARK>.
  22.  
  23. =for apidoc Am|void|PUSHMARK|SP
  24. Opening bracket for arguments on a callback.  See C<PUTBACK> and
  25. L<perlcall>.
  26.  
  27. =for apidoc Ams||dSP
  28. Declares a local copy of perl's stack pointer for the XSUB, available via
  29. the C<SP> macro.  See C<SP>.
  30.  
  31. =for apidoc ms||djSP
  32.  
  33. Declare Just C<SP>. This is actually identical to C<dSP>, and declares
  34. a local copy of perl's stack pointer, available via the C<SP> macro.
  35. See C<SP>.  (Available for backward source code compatibility with the
  36. old (Perl 5.005) thread model.)
  37.  
  38. =for apidoc Ams||dMARK
  39. Declare a stack marker variable, C<mark>, for the XSUB.  See C<MARK> and
  40. C<dORIGMARK>.
  41.  
  42. =for apidoc Ams||dORIGMARK
  43. Saves the original stack mark for the XSUB.  See C<ORIGMARK>.
  44.  
  45. =for apidoc AmU||ORIGMARK
  46. The original stack mark for the XSUB.  See C<dORIGMARK>.
  47.  
  48. =for apidoc Ams||SPAGAIN
  49. Refetch the stack pointer.  Used after a callback.  See L<perlcall>.
  50.  
  51. =cut */
  52.  
  53. #undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */
  54. #define SP sp
  55. #define MARK mark
  56. #define TARG targ
  57.  
  58. #define PUSHMARK(p)    \
  59.     STMT_START {                    \
  60.         if (++PL_markstack_ptr == PL_markstack_max)    \
  61.         markstack_grow();                \
  62.         *PL_markstack_ptr = (I32)((p) - PL_stack_base);\
  63.     } STMT_END
  64.  
  65. #define TOPMARK        (*PL_markstack_ptr)
  66. #define POPMARK        (*PL_markstack_ptr--)
  67.  
  68. #define dSP        SV **sp = PL_stack_sp
  69. #define djSP        dSP
  70. #define dMARK        register SV **mark = PL_stack_base + POPMARK
  71. #define dORIGMARK    const I32 origmark = (I32)(mark - PL_stack_base)
  72. #define ORIGMARK    (PL_stack_base + origmark)
  73.  
  74. #define SPAGAIN        sp = PL_stack_sp
  75. #define MSPAGAIN    STMT_START { sp = PL_stack_sp; mark = ORIGMARK; } STMT_END
  76.  
  77. #define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ))
  78. #define dTARGETSTACKED SV * GETTARGETSTACKED
  79.  
  80. #define GETTARGET targ = PAD_SV(PL_op->op_targ)
  81. #define dTARGET SV * GETTARGET
  82.  
  83. #define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ))
  84. #define dATARGET SV * GETATARGET
  85.  
  86. #define dTARG SV *targ
  87.  
  88. #define NORMAL PL_op->op_next
  89. #define DIE return Perl_die
  90.  
  91. /*
  92. =for apidoc Ams||PUTBACK
  93. Closing bracket for XSUB arguments.  This is usually handled by C<xsubpp>.
  94. See C<PUSHMARK> and L<perlcall> for other uses.
  95.  
  96. =for apidoc Amn|SV*|POPs
  97. Pops an SV off the stack.
  98.  
  99. =for apidoc Amn|char*|POPp
  100. Pops a string off the stack. Deprecated. New code should use POPpx.
  101.  
  102. =for apidoc Amn|char*|POPpx
  103. Pops a string off the stack.
  104.  
  105. =for apidoc Amn|char*|POPpbytex
  106. Pops a string off the stack which must consist of bytes i.e. characters < 256.
  107.  
  108. =for apidoc Amn|NV|POPn
  109. Pops a double off the stack.
  110.  
  111. =for apidoc Amn|IV|POPi
  112. Pops an integer off the stack.
  113.  
  114. =for apidoc Amn|long|POPl
  115. Pops a long off the stack.
  116.  
  117. =cut
  118. */
  119.  
  120. #define PUTBACK        PL_stack_sp = sp
  121. #define RETURN        return (PUTBACK, NORMAL)
  122. #define RETURNOP(o)    return (PUTBACK, o)
  123. #define RETURNX(x)    return (x, PUTBACK, NORMAL)
  124.  
  125. #define POPs        (*sp--)
  126. #define POPp        (SvPVx(POPs, PL_na))        /* deprecated */
  127. #define POPpx        (SvPVx_nolen(POPs))
  128. #define POPpconstx    (SvPVx_nolen_const(POPs))
  129. #define POPpbytex    (SvPVbytex_nolen(POPs))
  130. #define POPn        (SvNVx(POPs))
  131. #define POPi        ((IV)SvIVx(POPs))
  132. #define POPu        ((UV)SvUVx(POPs))
  133. #define POPl        ((long)SvIVx(POPs))
  134. #define POPul        ((unsigned long)SvIVx(POPs))
  135. #ifdef HAS_QUAD
  136. #define POPq        ((Quad_t)SvIVx(POPs))
  137. #define POPuq        ((Uquad_t)SvUVx(POPs))
  138. #endif
  139.  
  140. #define TOPs        (*sp)
  141. #define TOPm1s        (*(sp-1))
  142. #define TOPp1s        (*(sp+1))
  143. #define TOPp        (SvPV(TOPs, PL_na))        /* deprecated */
  144. #define TOPpx        (SvPV_nolen(TOPs))
  145. #define TOPn        (SvNV(TOPs))
  146. #define TOPi        ((IV)SvIV(TOPs))
  147. #define TOPu        ((UV)SvUV(TOPs))
  148. #define TOPl        ((long)SvIV(TOPs))
  149. #define TOPul        ((unsigned long)SvUV(TOPs))
  150. #ifdef HAS_QUAD
  151. #define TOPq        ((Quad_t)SvIV(TOPs))
  152. #define TOPuq        ((Uquad_t)SvUV(TOPs))
  153. #endif
  154.  
  155. /* Go to some pains in the rare event that we must extend the stack. */
  156.  
  157. /*
  158. =for apidoc Am|void|EXTEND|SP|int nitems
  159. Used to extend the argument stack for an XSUB's return values. Once
  160. used, guarantees that there is room for at least C<nitems> to be pushed
  161. onto the stack.
  162.  
  163. =for apidoc Am|void|PUSHs|SV* sv
  164. Push an SV onto the stack.  The stack must have room for this element.
  165. Does not handle 'set' magic.  Does not use C<TARG>.  See also C<PUSHmortal>,
  166. C<XPUSHs> and C<XPUSHmortal>.
  167.  
  168. =for apidoc Am|void|PUSHp|char* str|STRLEN len
  169. Push a string onto the stack.  The stack must have room for this element.
  170. The C<len> indicates the length of the string.  Handles 'set' magic.  Uses
  171. C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not
  172. call multiple C<TARG>-oriented macros to return lists from XSUB's - see
  173. C<mPUSHp> instead.  See also C<XPUSHp> and C<mXPUSHp>.
  174.  
  175. =for apidoc Am|void|PUSHn|NV nv
  176. Push a double onto the stack.  The stack must have room for this element.
  177. Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
  178. called to declare it.  Do not call multiple C<TARG>-oriented macros to
  179. return lists from XSUB's - see C<mPUSHn> instead.  See also C<XPUSHn> and
  180. C<mXPUSHn>.
  181.  
  182. =for apidoc Am|void|PUSHi|IV iv
  183. Push an integer onto the stack.  The stack must have room for this element.
  184. Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
  185. called to declare it.  Do not call multiple C<TARG>-oriented macros to 
  186. return lists from XSUB's - see C<mPUSHi> instead.  See also C<XPUSHi> and
  187. C<mXPUSHi>.
  188.  
  189. =for apidoc Am|void|PUSHu|UV uv
  190. Push an unsigned integer onto the stack.  The stack must have room for this
  191. element.  Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG>
  192. should be called to declare it.  Do not call multiple C<TARG>-oriented
  193. macros to return lists from XSUB's - see C<mPUSHu> instead.  See also
  194. C<XPUSHu> and C<mXPUSHu>.
  195.  
  196. =for apidoc Am|void|XPUSHs|SV* sv
  197. Push an SV onto the stack, extending the stack if necessary.  Does not
  198. handle 'set' magic.  Does not use C<TARG>.  See also C<XPUSHmortal>,
  199. C<PUSHs> and C<PUSHmortal>.
  200.  
  201. =for apidoc Am|void|XPUSHp|char* str|STRLEN len
  202. Push a string onto the stack, extending the stack if necessary.  The C<len>
  203. indicates the length of the string.  Handles 'set' magic.  Uses C<TARG>, so
  204. C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not call
  205. multiple C<TARG>-oriented macros to return lists from XSUB's - see
  206. C<mXPUSHp> instead.  See also C<PUSHp> and C<mPUSHp>.
  207.  
  208. =for apidoc Am|void|XPUSHn|NV nv
  209. Push a double onto the stack, extending the stack if necessary.  Handles
  210. 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
  211. declare it.  Do not call multiple C<TARG>-oriented macros to return lists
  212. from XSUB's - see C<mXPUSHn> instead.  See also C<PUSHn> and C<mPUSHn>.
  213.  
  214. =for apidoc Am|void|XPUSHi|IV iv
  215. Push an integer onto the stack, extending the stack if necessary.  Handles
  216. 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
  217. declare it.  Do not call multiple C<TARG>-oriented macros to return lists
  218. from XSUB's - see C<mXPUSHi> instead.  See also C<PUSHi> and C<mPUSHi>.
  219.  
  220. =for apidoc Am|void|XPUSHu|UV uv
  221. Push an unsigned integer onto the stack, extending the stack if necessary.
  222. Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
  223. called to declare it.  Do not call multiple C<TARG>-oriented macros to
  224. return lists from XSUB's - see C<mXPUSHu> instead.  See also C<PUSHu> and
  225. C<mPUSHu>.
  226.  
  227. =for apidoc Am|void|PUSHmortal
  228. Push a new mortal SV onto the stack.  The stack must have room for this
  229. element.  Does not handle 'set' magic.  Does not use C<TARG>.  See also
  230. C<PUSHs>, C<XPUSHmortal> and C<XPUSHs>.
  231.  
  232. =for apidoc Am|void|mPUSHp|char* str|STRLEN len
  233. Push a string onto the stack.  The stack must have room for this element.
  234. The C<len> indicates the length of the string.  Handles 'set' magic.  Does
  235. not use C<TARG>.  See also C<PUSHp>, C<mXPUSHp> and C<XPUSHp>.
  236.  
  237. =for apidoc Am|void|mPUSHn|NV nv
  238. Push a double onto the stack.  The stack must have room for this element.
  239. Handles 'set' magic.  Does not use C<TARG>.  See also C<PUSHn>, C<mXPUSHn>
  240. and C<XPUSHn>.
  241.  
  242. =for apidoc Am|void|mPUSHi|IV iv
  243. Push an integer onto the stack.  The stack must have room for this element.
  244. Handles 'set' magic.  Does not use C<TARG>.  See also C<PUSHi>, C<mXPUSHi>
  245. and C<XPUSHi>.
  246.  
  247. =for apidoc Am|void|mPUSHu|UV uv
  248. Push an unsigned integer onto the stack.  The stack must have room for this
  249. element.  Handles 'set' magic.  Does not use C<TARG>.  See also C<PUSHu>,
  250. C<mXPUSHu> and C<XPUSHu>.
  251.  
  252. =for apidoc Am|void|XPUSHmortal
  253. Push a new mortal SV onto the stack, extending the stack if necessary.  Does
  254. not handle 'set' magic.  Does not use C<TARG>.  See also C<XPUSHs>,
  255. C<PUSHmortal> and C<PUSHs>.
  256.  
  257. =for apidoc Am|void|mXPUSHp|char* str|STRLEN len
  258. Push a string onto the stack, extending the stack if necessary.  The C<len>
  259. indicates the length of the string.  Handles 'set' magic.  Does not use
  260. C<TARG>.  See also C<XPUSHp>, C<mPUSHp> and C<PUSHp>.
  261.  
  262. =for apidoc Am|void|mXPUSHn|NV nv
  263. Push a double onto the stack, extending the stack if necessary.  Handles
  264. 'set' magic.  Does not use C<TARG>.  See also C<XPUSHn>, C<mPUSHn> and
  265. C<PUSHn>.
  266.  
  267. =for apidoc Am|void|mXPUSHi|IV iv
  268. Push an integer onto the stack, extending the stack if necessary.  Handles
  269. 'set' magic.  Does not use C<TARG>.  See also C<XPUSHi>, C<mPUSHi> and
  270. C<PUSHi>.
  271.  
  272. =for apidoc Am|void|mXPUSHu|UV uv
  273. Push an unsigned integer onto the stack, extending the stack if necessary.
  274. Handles 'set' magic.  Does not use C<TARG>.  See also C<XPUSHu>, C<mPUSHu>
  275. and C<PUSHu>.
  276.  
  277. =cut
  278. */
  279.  
  280. #define EXTEND(p,n)    STMT_START { if (PL_stack_max - p < (int)(n)) {        \
  281.                 sp = stack_grow(sp,p, (int) (n));        \
  282.             } } STMT_END
  283.  
  284. /* Same thing, but update mark register too. */
  285. #define MEXTEND(p,n)    STMT_START {if (PL_stack_max - p < (int)(n)) {    \
  286.                 const int markoff = mark - PL_stack_base;    \
  287.                 sp = stack_grow(sp,p,(int) (n));        \
  288.                 mark = PL_stack_base + markoff;        \
  289.             } } STMT_END
  290.  
  291. #define PUSHs(s)    (*++sp = (s))
  292. #define PUSHTARG    STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END
  293. #define PUSHp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END
  294. #define PUSHn(n)    STMT_START { sv_setnv(TARG, (NV)(n)); PUSHTARG; } STMT_END
  295. #define PUSHi(i)    STMT_START { sv_setiv(TARG, (IV)(i)); PUSHTARG; } STMT_END
  296. #define PUSHu(u)    STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
  297.  
  298. #define XPUSHs(s)    STMT_START { EXTEND(sp,1); (*++sp = (s)); } STMT_END
  299. #define XPUSHTARG    STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END
  300. #define XPUSHp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END
  301. #define XPUSHn(n)    STMT_START { sv_setnv(TARG, (NV)(n)); XPUSHTARG; } STMT_END
  302. #define XPUSHi(i)    STMT_START { sv_setiv(TARG, (IV)(i)); XPUSHTARG; } STMT_END
  303. #define XPUSHu(u)    STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
  304. #define XPUSHundef    STMT_START { SvOK_off(TARG); XPUSHs(TARG); } STMT_END
  305.  
  306. #define PUSHmortal    PUSHs(sv_newmortal())
  307. #define mPUSHp(p,l)    sv_setpvn_mg(PUSHmortal, (p), (l))
  308. #define mPUSHn(n)    sv_setnv_mg(PUSHmortal, (NV)(n))
  309. #define mPUSHi(i)    sv_setiv_mg(PUSHmortal, (IV)(i))
  310. #define mPUSHu(u)    sv_setuv_mg(PUSHmortal, (UV)(u))
  311.  
  312. #define XPUSHmortal    XPUSHs(sv_newmortal())
  313. #define mXPUSHp(p,l)    STMT_START { EXTEND(sp,1); sv_setpvn_mg(PUSHmortal, (p), (l)); } STMT_END
  314. #define mXPUSHn(n)    STMT_START { EXTEND(sp,1); sv_setnv_mg(PUSHmortal, (NV)(n)); } STMT_END
  315. #define mXPUSHi(i)    STMT_START { EXTEND(sp,1); sv_setiv_mg(PUSHmortal, (IV)(i)); } STMT_END
  316. #define mXPUSHu(u)    STMT_START { EXTEND(sp,1); sv_setuv_mg(PUSHmortal, (UV)(u)); } STMT_END
  317.  
  318. #define SETs(s)        (*sp = s)
  319. #define SETTARG        STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END
  320. #define SETp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END
  321. #define SETn(n)        STMT_START { sv_setnv(TARG, (NV)(n)); SETTARG; } STMT_END
  322. #define SETi(i)        STMT_START { sv_setiv(TARG, (IV)(i)); SETTARG; } STMT_END
  323. #define SETu(u)        STMT_START { sv_setuv(TARG, (UV)(u)); SETTARG; } STMT_END
  324.  
  325. #define dTOPss        SV *sv = TOPs
  326. #define dPOPss        SV *sv = POPs
  327. #define dTOPnv        NV value = TOPn
  328. #define dPOPnv        NV value = POPn
  329. #define dTOPiv        IV value = TOPi
  330. #define dPOPiv        IV value = POPi
  331. #define dTOPuv        UV value = TOPu
  332. #define dPOPuv        UV value = POPu
  333. #ifdef HAS_QUAD
  334. #define dTOPqv        Quad_t value = TOPu
  335. #define dPOPqv        Quad_t value = POPu
  336. #define dTOPuqv        Uquad_t value = TOPuq
  337. #define dPOPuqv        Uquad_t value = POPuq
  338. #endif
  339.  
  340. #define dPOPXssrl(X)    SV *right = POPs; SV *left = CAT2(X,s)
  341. #define dPOPXnnrl(X)    NV right = POPn; NV left = CAT2(X,n)
  342. #define dPOPXiirl(X)    IV right = POPi; IV left = CAT2(X,i)
  343.  
  344. #define USE_LEFT(sv) \
  345.     (SvOK(sv) || SvGMAGICAL(sv) || !(PL_op->op_flags & OPf_STACKED))
  346. #define dPOPXnnrl_ul(X)    \
  347.     NV right = POPn;                \
  348.     SV *leftsv = CAT2(X,s);                \
  349.     NV left = USE_LEFT(leftsv) ? SvNV(leftsv) : 0.0
  350. #define dPOPXiirl_ul(X) \
  351.     IV right = POPi;                    \
  352.     SV *leftsv = CAT2(X,s);                \
  353.     IV left = USE_LEFT(leftsv) ? SvIV(leftsv) : 0
  354.  
  355. #define dPOPPOPssrl    dPOPXssrl(POP)
  356. #define dPOPPOPnnrl    dPOPXnnrl(POP)
  357. #define dPOPPOPnnrl_ul    dPOPXnnrl_ul(POP)
  358. #define dPOPPOPiirl    dPOPXiirl(POP)
  359. #define dPOPPOPiirl_ul    dPOPXiirl_ul(POP)
  360.  
  361. #define dPOPTOPssrl    dPOPXssrl(TOP)
  362. #define dPOPTOPnnrl    dPOPXnnrl(TOP)
  363. #define dPOPTOPnnrl_ul    dPOPXnnrl_ul(TOP)
  364. #define dPOPTOPiirl    dPOPXiirl(TOP)
  365. #define dPOPTOPiirl_ul    dPOPXiirl_ul(TOP)
  366.  
  367. #define RETPUSHYES    RETURNX(PUSHs(&PL_sv_yes))
  368. #define RETPUSHNO    RETURNX(PUSHs(&PL_sv_no))
  369. #define RETPUSHUNDEF    RETURNX(PUSHs(&PL_sv_undef))
  370.  
  371. #define RETSETYES    RETURNX(SETs(&PL_sv_yes))
  372. #define RETSETNO    RETURNX(SETs(&PL_sv_no))
  373. #define RETSETUNDEF    RETURNX(SETs(&PL_sv_undef))
  374.  
  375. #define ARGTARG        PL_op->op_targ
  376.  
  377.     /* See OPpTARGET_MY: */
  378. #define MAXARG        (PL_op->op_private & 15)
  379.  
  380. #define SWITCHSTACK(f,t) \
  381.     STMT_START {                            \
  382.     AvFILLp(f) = sp - PL_stack_base;                \
  383.     PL_stack_base = AvARRAY(t);                    \
  384.     PL_stack_max = PL_stack_base + AvMAX(t);            \
  385.     sp = PL_stack_sp = PL_stack_base + AvFILLp(t);            \
  386.     PL_curstack = t;                        \
  387.     } STMT_END
  388.  
  389. #define EXTEND_MORTAL(n) \
  390.     STMT_START {                            \
  391.     if (PL_tmps_ix + (n) >= PL_tmps_max)                \
  392.         tmps_grow(n);                        \
  393.     } STMT_END
  394.  
  395. #define AMGf_noright    1
  396. #define AMGf_noleft    2
  397. #define AMGf_assign    4
  398. #define AMGf_unary    8
  399.  
  400. #define tryAMAGICbinW_var(meth_enum,assign,set) STMT_START { \
  401.         SV* const left = *(sp-1); \
  402.         SV* const right = *(sp); \
  403.         if ((SvAMAGIC(left)||SvAMAGIC(right))) {\
  404.         SV * const tmpsv = amagic_call(left, \
  405.                    right, \
  406.                    (meth_enum), \
  407.                    (assign)? AMGf_assign: 0); \
  408.         if (tmpsv) { \
  409.             SPAGAIN; \
  410.             (void)POPs; set(tmpsv); RETURN; } \
  411.         } \
  412.     } STMT_END
  413.  
  414. #define tryAMAGICbinW(meth,assign,set) \
  415.     tryAMAGICbinW_var(CAT2(meth,_amg),assign,set)
  416.  
  417. #define tryAMAGICbin_var(meth_enum,assign) \
  418.         tryAMAGICbinW_var(meth_enum,assign,SETsv)
  419. #define tryAMAGICbin(meth,assign) \
  420.         tryAMAGICbin_var(CAT2(meth,_amg),assign)
  421.  
  422. #define tryAMAGICbinSET(meth,assign) tryAMAGICbinW(meth,assign,SETs)
  423.  
  424. #define tryAMAGICbinSET_var(meth_enum,assign) \
  425.     tryAMAGICbinW_var(meth_enum,assign,SETs)
  426.  
  427. #define AMG_CALLun_var(sv,meth_enum) amagic_call(sv,&PL_sv_undef,  \
  428.                     meth_enum,AMGf_noright | AMGf_unary)
  429. #define AMG_CALLun(sv,meth) AMG_CALLun_var(sv,CAT2(meth,_amg))
  430.  
  431. #define AMG_CALLbinL(left,right,meth) \
  432.             amagic_call(left,right,CAT2(meth,_amg),AMGf_noright)
  433.  
  434. #define tryAMAGICunW_var(meth_enum,set,shift,ret) STMT_START { \
  435.         SV* tmpsv; \
  436.         SV* arg= sp[shift]; \
  437.           if(0) goto am_again;  /* shut up unused warning */ \
  438.       am_again: \
  439.         if ((SvAMAGIC(arg))&&\
  440.         (tmpsv=AMG_CALLun_var(arg,(meth_enum)))) {\
  441.            SPAGAIN; if (shift) sp += shift; \
  442.            set(tmpsv); ret; } \
  443.     } STMT_END
  444. #define tryAMAGICunW(meth,set,shift,ret) \
  445.     tryAMAGICunW_var(CAT2(meth,_amg),set,shift,ret)
  446.  
  447. #define FORCE_SETs(sv) STMT_START { sv_setsv(TARG, (sv)); SETTARG; } STMT_END
  448.  
  449. #define tryAMAGICun_var(meth_enum) tryAMAGICunW_var(meth_enum,SETsvUN,0,RETURN)
  450. #define tryAMAGICun(meth)    tryAMAGICun_var(CAT2(meth,_amg))
  451. #define tryAMAGICunSET(meth)    tryAMAGICunW(meth,SETs,0,RETURN)
  452. #define tryAMAGICunTARGET(meth, shift)                    \
  453.     STMT_START { dSP; sp--;     /* get TARGET from below PL_stack_sp */        \
  454.         { dTARGETSTACKED;                         \
  455.         { dSP; tryAMAGICunW(meth,FORCE_SETs,shift,RETURN);}}} STMT_END
  456.  
  457. #define setAGAIN(ref)    \
  458.     STMT_START {                    \
  459.     sv = ref;                    \
  460.     if (!SvROK(ref))                \
  461.         Perl_croak(aTHX_ "Overloaded dereference did not return a reference");    \
  462.     if (ref != arg && SvRV(ref) != SvRV(arg)) {    \
  463.         arg = ref;                    \
  464.         goto am_again;                \
  465.     }                        \
  466.     } STMT_END
  467.  
  468. #define tryAMAGICunDEREF(meth) tryAMAGICunW(meth,setAGAIN,0,(void)0)
  469. #define tryAMAGICunDEREF_var(meth_enum) \
  470.     tryAMAGICunW_var(meth_enum,setAGAIN,0,(void)0)
  471.  
  472. #define opASSIGN (PL_op->op_flags & OPf_STACKED)
  473. #define SETsv(sv)    STMT_START {                    \
  474.         if (opASSIGN || (SvFLAGS(TARG) & SVs_PADMY))        \
  475.            { sv_setsv(TARG, (sv)); SETTARG; }            \
  476.         else SETs(sv); } STMT_END
  477.  
  478. #define SETsvUN(sv)    STMT_START {                    \
  479.         if (SvFLAGS(TARG) & SVs_PADMY)        \
  480.            { sv_setsv(TARG, (sv)); SETTARG; }            \
  481.         else SETs(sv); } STMT_END
  482.  
  483. /* newSVsv does not behave as advertised, so we copy missing
  484.  * information by hand */
  485.  
  486. /* SV* ref causes confusion with the member variable
  487.    changed SV* ref to SV* tmpRef */
  488. #define RvDEEPCP(rv) STMT_START { SV* tmpRef=SvRV(rv);      \
  489.   if (SvREFCNT(tmpRef)>1) {                 \
  490.     SvRV_set(rv, AMG_CALLun(rv,copy));    \
  491.     SvREFCNT_dec(tmpRef);                   \
  492.   } } STMT_END
  493.  
  494. /*
  495. =for apidoc mU||LVRET
  496. True if this op will be the return value of an lvalue subroutine
  497.  
  498. =cut */
  499. #define LVRET ((PL_op->op_private & OPpMAYBE_LVSUB) && is_lvalue_sub())
  500.  
  501. /*
  502.  * Local variables:
  503.  * c-indentation-style: bsd
  504.  * c-basic-offset: 4
  505.  * indent-tabs-mode: t
  506.  * End:
  507.  *
  508.  * ex: set ts=8 sts=4 sw=4 noet:
  509.  */
  510.